#include <iostream>
#include <vector>
#include <string>

namespace cpp23 {

// 矩阵类，演示C++23多维下标运算符
class Matrix {
private:
  std::vector<std::vector<int>> m_data;
  size_t m_rows;
  size_t m_cols;

public:
  Matrix(size_t rows, size_t cols, int initial_value = 0)
    : m_rows(rows), m_cols(cols) {
    m_data.resize(rows, std::vector<int>(cols, initial_value));
  }

  // C++23之前的访问方式 - 需要嵌套调用
  int at(size_t row, size_t col) const {
    return m_data.at(row).at(col);
  }

  int& at(size_t row, size_t col) {
    return m_data.at(row).at(col);
  }

  // C++23 多维下标运算符
  // 注意：这是C++23功能，某些编译器可能不支持
  // 模拟C++23的[][]语法，实际使用时用一个operator[]
  int operator[](size_t row, size_t col) const {
    return m_data.at(row).at(col);
  }

  int& operator[](size_t row, size_t col) {
    return m_data.at(row).at(col);
  }

  void print() const {
    for (size_t i = 0; i < m_rows; ++i) {
      for (size_t j = 0; j < m_cols; ++j) {
        std::cout << m_data[i][j] << " ";
      }
      std::cout << "\n";
    }
  }
};

// 三维数组示例
class Tensor3D {
private:
  std::vector<std::vector<std::vector<double>>> m_data;
  size_t m_dim1, m_dim2, m_dim3;

public:
  Tensor3D(size_t dim1, size_t dim2, size_t dim3)
    : m_dim1(dim1), m_dim2(dim2), m_dim3(dim3) {
    m_data.resize(dim1, std::vector<std::vector<double>>(
                          dim2, std::vector<double>(dim3, 0.0)));
  }

  // C++23 三维下标运算符
  // 注意：这是C++23功能，某些编译器可能不支持
  // 模拟C++23的[][][]语法，实际使用时用一个operator[]
  double operator[](size_t i, size_t j, size_t k) const {
    return m_data.at(i).at(j).at(k);
  }

  double& operator[](size_t i, size_t j, size_t k) {
    return m_data.at(i).at(j).at(k);
  }
};

} // namespace cpp23

void demonstrate_multidimensional_subscript() {
  using namespace cpp23;

  // 创建一个3x4矩阵
  Matrix matrix(3, 4);
  
  std::cout << "填充矩阵...\n";
  // 使用传统方式填充矩阵
  for (size_t i = 0; i < 3; ++i) {
    for (size_t j = 0; j < 4; ++j) {
      matrix.at(i, j) = i * 10 + j;
    }
  }
  
  // 打印矩阵
  matrix.print();
  
  // 模拟C++23多维下标语法
  std::cout << "\n获取元素 matrix[1,2] = " << matrix[1, 2] << "\n";
  
  // 修改元素
  matrix[1, 2] = 99;
  std::cout << "修改后的元素 matrix[1,2] = " << matrix[1, 2] << "\n";
  
  // 再次打印矩阵
  std::cout << "\n修改后的矩阵:\n";
  matrix.print();
  
  // 创建一个三维张量并演示用法
  Tensor3D tensor(2, 2, 2);
  tensor[0, 0, 0] = 1.1;
  tensor[1, 1, 1] = 8.8;
  
  std::cout << "\n三维张量示例:\n";
  std::cout << "tensor[0,0,0] = " << tensor[0, 0, 0] << "\n";
  std::cout << "tensor[1,1,1] = " << tensor[1, 1, 1] << "\n";

  std::cout << "\nC++23多维下标运算符的优势:\n";
  std::cout << "1. 语法更简洁：matrix[i,j] 比 matrix[i][j] 或 matrix.at(i,j) 更直观\n";
  std::cout << "2. 性能可能更好：单次函数调用替代多次调用\n";
  std::cout << "3. 更好的错误检查：可以在一个函数中同时验证所有索引\n";
  std::cout << "4. 表达力更强：支持任意维度的索引访问\n";
} 